package cn.edu.nuc.bre.service;

import java.util.ArrayList;
import java.util.Date;
import java.util.HashMap;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.Set;

import org.activiti.engine.HistoryService;
import org.activiti.engine.IdentityService;
import org.activiti.engine.RuntimeService;
import org.activiti.engine.TaskService;
import org.activiti.engine.history.HistoricActivityInstance;
import org.activiti.engine.history.HistoricProcessInstance;
import org.activiti.engine.history.HistoricTaskInstance;
import org.activiti.engine.history.HistoricTaskInstanceQuery;
import org.activiti.engine.identity.Group;
import org.activiti.engine.identity.User;
import org.activiti.engine.runtime.ProcessInstance;
import org.activiti.engine.task.Comment;
import org.activiti.engine.task.Task;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import cn.edu.nuc.bre.dao.QueryMapper;
import cn.edu.nuc.bre.dao.TransactionMapper;
import cn.edu.nuc.bre.dto.QueryHandler;
import cn.edu.nuc.bre.entity.Transaction;
import cn.edu.nuc.bre.service.interfaces.ChildTaskService;
import cn.edu.nuc.bre.service.interfaces.GroupService;
import cn.edu.nuc.bre.service.interfaces.TransactionService;
import cn.edu.nuc.bre.util.BreInfo;
import cn.edu.nuc.bre.util.PageInfo;

/**
 * 事务流程服务
 * 
 * @author 王小强
 * @since 2016年11月10日_上午9:09:07
 */
@Service
public class TransactionServiceImpl implements TransactionService {
	@Autowired
	private QueryMapper qm;

	@Autowired
	private TransactionMapper transactionMapper;

	@Autowired
	private ChildTaskService childTaskService;

	@Autowired
	private RuntimeService runtimeService;

	@Autowired
	private TaskService taskService;

	@Autowired
	private HistoryService historyService;

	@Autowired
	private IdentityService identityService;

	@Autowired
	private GroupService groupService;

	@Transactional(rollbackFor = { Exception.class })
	@Override
	public boolean addAndStart(Transaction one) throws Exception {
		if (one == null || one.getUsername() == null) {
			throw new RuntimeException("事务用户名为空。。。");
		}
		
		/**
		 * 传入超时时间要先计算好 一些初始化工作
		 */
		one.setTstate(BreInfo.TRANSACTION_RESPOND_CHECK);// 直接设置为初审响应,没有新事务申报的状态
		one.setTsubmittime(new Date()); // 上报时间
		one.setTurge(0);// 催办次数
		one.setTpresident(0);// 未提交行长

		/**
		 * bussinesskey设为事务id,并通过流程定义key启动一个流程,指定事务申报人name
		 * runtimeService.startProcessInstanceByKey(processDefinitionKey,
		 * businessKey, variables)
		 */
		Integer tid = one.getTid();
		String startAssignee = one.getUsername();// 执行人姓名
		Map<String, Object> startVariables = new HashMap<String, Object>();
		startVariables.put(BreInfo.START_ASSIGNEE_NAME, startAssignee);// 指定新事务申报执行人
		
		// 启动一个新流程实例并设置事务的流程实例id
		ProcessInstance instance = runtimeService.startProcessInstanceByKey(BreInfo.PROCESS_DEFINITION_KEY, tid + "", startVariables);
		one.setProcinstid(instance.getProcessInstanceId());
		
		/**
		 * 新增一条事务记录,返回记录的编号
		 */
		if (transactionMapper.insert(one) != 1) {
			throw new RuntimeException("新事务记录添加失败。。。");
		}
		
		/**
		 * 将任务结点执行到待响应审核
		 */
		// 获取当前流程实例的任务
		Task task = getTaskByBusinessKeyAndAssignee(tid, startAssignee, false);
		String taskid = task.getId();
		
		// 获取网管中心组所有用户 并格式化为字符串
		String checkUsrs = formatUserInfoForGroup(BreInfo.GROUP_ID_MASTER);
		
		// 执行到下一节点,审核响应
		Map<String, Object> checkVariables = new HashMap<String, Object>();
		checkVariables.put(BreInfo.CHECK_USERS_NAME, checkUsrs);

		// 执行并验证指定任务是否执行完成
		return completeTask(taskid, checkVariables);
	}

	// >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
	@Transactional(rollbackFor = { Exception.class })
	@Override
	public boolean respondTocheckTranaction(String userName, Integer tid, Date endTime) throws Exception {
		/* 待响应审核组任务拾取 */
		// 获取指定组任务
		Task targeClaimTask = getTaskByBusinessKeyAndAssignee(tid, userName, true);
		// 拾取
		taskService.claim(targeClaimTask.getId(), userName);
		// 执行该任务,id并没有变化,所以可以直接执行
		// 需要指定下一个节点的执行人[网点审核执行人]
		Map<String, Object> variables = new HashMap<String, Object>();
		variables.put(BreInfo.CHECK_ASSIGNEE_NAME, userName);
		if (completeTask(targeClaimTask.getId(), variables)) {
			// 执行成功,修改事务状态为[审核]以及设置新超时时间
			this.editState(tid, BreInfo.TRANSACTION_CHECK, endTime);
		} else {
			// 执行失败
			throw new RuntimeException("执行组任务失败。。。");
		}
		return true;
	}

	@Transactional(rollbackFor = { Exception.class })
	@Override
	public boolean checkTranactionNextEnd(String userName, Integer tid) throws Exception {
		/* 网管审核任务不通过 */
		// 获取指定任务
		Task targeCompleteTask = getTaskByBusinessKeyAndAssignee(tid, userName, false);
		// 执行该任务,设置审核变量为驳回
		Map<String, Object> variables = new HashMap<String, Object>();
		variables.put(BreInfo.CHECK_FLAG_NAME, BreInfo.CHECK_FLAG_DISALLOW);
		if (completeTask(targeCompleteTask.getId(), variables)) {
			// 执行成功,修改事务状态为[驳回结束状态],超时无需设置
			this.editState(tid, BreInfo.TRANSACTION_END_ERROR, null);
		} else {
			// 执行失败
			throw new RuntimeException("执行任务失败。。。");
		}
		return true;
	}

	@Transactional(rollbackFor = { Exception.class })
	@Override
	public boolean checkTranactionNextDeptDeal(String userName, Integer tid, Date endTime,
			cn.edu.nuc.bre.entity.Task... childTasks) throws Exception {
		/* 网管审核任务通过并指定子任务 */
		if (childTasks == null || childTasks.length < 1) {
			throw new RuntimeException("未指定子任务信息。。。");
		}
		List<String> deptList = new ArrayList<>();
		// 先循环添加子任务,并构造指定部门list
		Group oneGroup = null;
		String formatStr = null;
		for (cn.edu.nuc.bre.entity.Task childTask : childTasks) {
			// 初始化子任务状态
			childTask.setTstate(BreInfo.CHILD_TASK_RESPOND_PROCESS);// 待响应
			if (childTaskService.add(childTask)) {
				// 通过角色名获取角色信息
				oneGroup = groupService.findByName(childTask.getDname());
				// 添加部门候选人
				formatStr = formatUserInfoForGroup(oneGroup.getId());
				deptList.add(formatStr);
			} else {
				throw new RuntimeException("子任务添加失败。。。");
			}
		}
		// 获取指定审核任务id
		Task targeCompleteTask = getTaskByBusinessKeyAndAssignee(tid, userName, false);
		// 执行该任务,设置审核变量为通过并设置分配部门
		Map<String, Object> variables = new HashMap<String, Object>();
		variables.put(BreInfo.CHECK_FLAG_NAME, BreInfo.CHECK_FLAG_PASS);
		variables.put(BreInfo.DEPT_LIST_NAME, deptList);
		if (completeTask(targeCompleteTask.getId(), variables)) {
			// 执行成功,修改事务状态为[带处理响应],设置超时
			this.editState(tid, BreInfo.TRANSACTION_RESPOND_PROCESS, endTime);
		} else {
			// 执行失败
			throw new RuntimeException("执行任务失败。。。");
		}
		return true;
	}

	@Transactional(rollbackFor = { Exception.class })
	@Override
	public boolean respondToProcessTranaction(String userName, Integer tid, String deptName) throws Exception {
		/* 待响应处理组任务拾取 */
		// 通过部门id和事务id获取指定子任务
		cn.edu.nuc.bre.entity.Task childTask = getChildTaskByTidAndDeptName(tid, deptName);
		// 获取指定组任务
		Task targeClaimTask = getTaskByBusinessKeyAndAssignee(tid, userName, true);
		// 拾取
		taskService.claim(targeClaimTask.getId(), userName);
		// 执行该任务,id并没有变化,所以可以直接执行
		// 需要指定下一个节点的执行人[网点审核执行人]
		Map<String, Object> variables = new HashMap<String, Object>();
		variables.put(BreInfo.DEPT_ASSIGNEE_NAME, userName);
		if (completeTask(targeClaimTask.getId(), variables)) {
			// 执行成功,修改子任务状态为[处理中]
			childTaskService.editState(childTask.getTaskid(), BreInfo.CHILD_TASK_PROCESS);
		} else {
			// 执行失败
			throw new RuntimeException("执行组任务失败。。。");
		}
		return true;
	}

	@Transactional(rollbackFor = { Exception.class })
	@Override
	public boolean processTranactionNextForWord(Integer tid, String deptName, String userName,
			cn.edu.nuc.bre.entity.Task newChildTask) throws Exception {
		/* 处理子任务结束并转发新的子任务 */
		// 先添加子任务
		Group oneGroup = null;
		String formatStr = null;
		newChildTask.setTstate(BreInfo.CHILD_TASK_RESPOND_PROCESS);// 待响应
		if (childTaskService.add(newChildTask)) {
			// 通过角色名获取角色信息
			oneGroup = groupService.findByName(newChildTask.getDname());
			// 添加部门候选人
			formatStr = formatUserInfoForGroup(oneGroup.getId());
		} else {
			throw new RuntimeException("子任务添加失败。。。");
		}

		// 使子任务变为结束并转发
		// 获取子任务
		cn.edu.nuc.bre.entity.Task oldChildTask = getChildTaskByTidAndDeptName(tid, deptName);
		// 获取指定处理任务id
		Task targeCompleteTask = getTaskByBusinessKeyAndAssignee(tid, userName, false);
		// 设置子任务转发参数,以及转发部门
		Map<String, Object> variables = new HashMap<String, Object>();
		variables.put(BreInfo.PROCESS_FLAG_NAME, BreInfo.PROCESS_FLAG_FORWARD);// 设置结束并转发
		variables.put(BreInfo.DEPT_LIST_ITEM_NAME, formatStr);
		if (completeTask(targeCompleteTask.getId(), variables)) {
			// 执行成功,修改子任务状态为[结束]
			childTaskService.editState(oldChildTask.getTaskid(), BreInfo.CHILD_TASK_END);
		} else {
			// 执行失败
			throw new RuntimeException("执行任务转发失败。。。");
		}
		return true;
	}

	@Transactional(rollbackFor = { Exception.class })
	@Override
	public boolean processTranactionNextEnd(Integer tid, String userName, String deptName) throws Exception {
		/* 处理子任务结束 */
		// 获取子任务
		cn.edu.nuc.bre.entity.Task childTask = getChildTaskByTidAndDeptName(tid, deptName);

		// 获取指定处理任务id
		Task targeCompleteTask = getTaskByBusinessKeyAndAssignee(tid, userName, false);
		// 设置子任务转发参数,以及转发部门
		Map<String, Object> variables = new HashMap<String, Object>();
		variables.put(BreInfo.PROCESS_FLAG_NAME, BreInfo.PROCESS_FLAG_END);// 设置结束
		if (completeTask(targeCompleteTask.getId(), variables)) {
			// 执行成功,修改子任务状态为[结束]
			childTaskService.editState(childTask.getTaskid(), BreInfo.CHILD_TASK_END);
			// 验证子任务是否都完成
			if (childTaskService.isFinishedByTid(tid)) {
				// 设置事务状态为待办结
				this.editState(tid, BreInfo.TRANSACTION_RESPOND_END, null);
			}
		} else {
			// 执行失败
			throw new RuntimeException("处理结束任务失败。。。");
		}

		return true;
	}

	@Transactional(rollbackFor = { Exception.class })
	@Override
	public boolean closeTranactionNextEnd(String userName, Integer tid, String tsatisfdesc, Integer tsatisfaction)
			throws Exception {
		/* 处理网点办结事务 */
		// 获取任务
		Task targeCompleteTask = getTaskByBusinessKeyAndAssignee(tid, userName, false);
		// 设置完结
		Map<String, Object> variables = new HashMap<String, Object>();
		variables.put(BreInfo.CLOSE_FLAG_NAME, BreInfo.CLOSE_FLAG_END);// 设置结束

		if (completeTask(targeCompleteTask.getId(), variables)) {
			// 执行成功,完善事务新属性,并设置状态为结束
			Transaction one = new Transaction();
			one.setTid(tid);
			one.setTsatisfaction(tsatisfaction);// 打分
			one.setTsatisfdesc(tsatisfdesc);// 描述
			one.setTstate(BreInfo.TRANSACTION_END_OK);// 已办结状态
			// 执行更新
			if (transactionMapper.updateByPrimaryKeySelective(one) != 1) {
				throw new RuntimeException("更新事务信息失败。。。");
			}
		} else {
			// 执行失败
			throw new RuntimeException("处理结束任务失败。。。");
		}
		return true;
	}

	@Transactional(rollbackFor = { Exception.class })
	@Override
	public boolean closeTranactionNextRollBack(String userName, Integer tid, String deptid) throws Exception {
		/* 处理网点驳回事务 */
		// 获取任务
		Task targeCompleteTask = getTaskByBusinessKeyAndAssignee(tid, userName, false);
		// 设置驳回
		Map<String, Object> variables = new HashMap<String, Object>();
		variables.put(BreInfo.CLOSE_FLAG_NAME, BreInfo.CLOSE_FLAG_DISALLOW);// 设置驳回
		// 修改事务状态为待处理响应
		if (completeTask(targeCompleteTask.getId(), variables)) {
			// 执行成功,完善事务新属性,并设置状态为结束
			Transaction one = new Transaction();
			one.setTid(tid);
			one.setTstate(BreInfo.TRANSACTION_RESPOND_PROCESS);// 待处理响应状态
			// 执行更新
			if (transactionMapper.updateByPrimaryKeySelective(one) != 1) {
				throw new RuntimeException("更新事务信息失败。。。");
			}
		} else {
			// 执行失败
			throw new RuntimeException("处理驳回任务失败。。。");
		}
		return true;
	}

	@Override
	public boolean giveUpTranaction(Integer tid) {
		/* 放弃指定事务 */
		Transaction one = findById(tid);
		int state = one.getTstate().intValue();
		if (state != BreInfo.TRANSACTION_RESPOND_CHECK // 验证事务当前状态
				&& state != BreInfo.TRANSACTION_RESPOND_CHECK) {
			// 发送指定消息
			runtimeService.signalEventReceived(BreInfo.GIVE_UP_SIGNAL_NAME);
			// 设置事务状态为放弃
			this.editState(tid, BreInfo.TRANSACTION_END_GIVE_UP, null);
			return true;
		}
		return false;
	}

	@Override
	public boolean editTpresidentCode(Integer tid, boolean tpresidentFlag) {
		Transaction one = new Transaction();
		one.setTid(tid);
		if (tpresidentFlag) {
			one.setTpresident(1);
		} else {
			one.setTpresident(0);
		}
		if (transactionMapper.updateByPrimaryKeySelective(one) != 1) {
			System.out.println("设置提交行长字段操作失败...");
			throw new RuntimeException("设置提交行长字段操作失败...");
		}
		return true;
	}

	@Override
	public boolean editTimeout(Integer tid, Date ttimeout) {
		this.editState(tid, null, ttimeout);
		return true;
	}

	// >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>

	@Override
	public List<Task> findTasksById(Integer tid) {
		// 通过事务id获取流程实例id
		ProcessInstance pi = getProcessInstanceByTid(tid);
		// 通过流程实例id获取当前执行结点任务
		return taskService.createTaskQuery().processInstanceId(pi.getId()).list();
	}

	@Override
	public boolean addComment(Integer tid, String taskId, String msgType, String msg) {
		// TODO 自动生成的方法存根
		ProcessInstance pi = getProcessInstanceByTid(tid);
		if (taskService.addComment(taskId, pi.getId(), msgType, msg) == null) {
			System.out.println("批注失败。。。");
			return false;
		} else {
			if ("催办".equals(msgType)) {// 催办
				Transaction one = this.findById(tid);
				int turge = 0;
				if (one != null) {
					turge = one.getTurge().intValue() + 1;
					// 执行更新
					Transaction temp = new Transaction();
					one.setTid(tid);
					one.setTurge(turge);
					if (transactionMapper.updateByPrimaryKeySelective(temp) != 1) {
						System.out.println("修改催办次数失败...");
						return false;
					}
				} else {
					System.out.println("指定事务不存在...");
					return false;
				}
			}
		}
		return true;
	}

	@Override
	public List<Comment> findCommentsById(Integer tid) {
		// TODO 自动生成的方法存根
		ProcessInstance pi = this.getProcessInstanceByTid(tid);
		if (pi != null) {
			return taskService.getProcessInstanceComments(pi.getId());
		} else {
			System.out.println("获取流程实例失败");
		}
		return null;
	}

	@Override
	public List<cn.edu.nuc.bre.entity.Task> findChildTasksById(Integer tid) {
		// TODO 自动生成的方法存根
		// 设定筛选条件
		QueryHandler qh = QueryHandler.creat().andColumnMark("tid", "=", tid + "").set();
		PageInfo<cn.edu.nuc.bre.entity.Task> pageinfo = childTaskService.findByQueryHandler(qh);
		return pageinfo != null ? pageinfo.getBasePageList() : null;
	}

	@Override
	public List<HistoricActivityInstance> findHistoricActivityInstanceById(Integer tid) {
		// TODO 自动生成的方法存根
		ProcessInstance pi = this.getProcessInstanceByTid(tid);
		if (pi != null) {
			return historyService.createHistoricActivityInstanceQuery().processInstanceId(pi.getId())
					.orderByHistoricActivityInstanceStartTime()// 依据开始时间,可以修改
					.list();
		} else {
			System.out.println("获取流程实例失败");
		}
		return null;
	}

	@Override
	public List<Transaction> findFinishedByAssignee(String assigneeName) {
		// TODO 自动生成的方法存根
		// 设置事务流程为完成状态
		return getSomeByAssigneeWithFlag(assigneeName, true, true);
	}

	@Override
	public List<Transaction> findFollowingByAssignee(String assigneeName) {
		// TODO 自动生成的方法存根
		// 设置事务流程为未完成状态
		return getSomeByAssigneeWithFlag(assigneeName, false, false);
	}

	@Override
	public List<Transaction> findNeedDealByAssignee(String assigneeName) {
		// 分为 需要自己办的
		List<Task> list = taskService.createTaskQuery().taskAssignee(assigneeName)// 指定个人任务查询
				.list();
		Set<String> piIds = new HashSet<String>();
		for (Task taskone : list) {
			piIds.add(taskone.getProcessInstanceId());
		}
		return this.findNeedDealOrClaimByAssignee(assigneeName, piIds);
	}

	@Override
	public List<Transaction> findNeedClaimByAssignee(String assigneeName) {
		// 可以响应的
		List<Task> respondList = taskService.createTaskQuery().taskCandidateUser(assigneeName).list();
		// 通过任务结点获取流程

		Set<String> piIds = new HashSet<String>();

		for (Task tasktwo : respondList) {
			piIds.add(tasktwo.getProcessInstanceId());
		}
		return this.findNeedDealOrClaimByAssignee(assigneeName, piIds);
	}

	private List<Transaction> findNeedDealOrClaimByAssignee(String assigneeName, Set<String> piIds) {
		// TODO 自动生成的方法存根
		// 根据流程实例id获取所有流程实例
		List<HistoricProcessInstance> processInstances = historyService.createHistoricProcessInstanceQuery()
				.processInstanceIds(piIds).list();

		// 获取事务流程
		Set<String> tids = new HashSet<String>();
		for (HistoricProcessInstance historicProcessInstance : processInstances) {
			tids.add(historicProcessInstance.getBusinessKey());
		}
		// 获取查询事务列表
		return this.findByTidSet(tids);
	}

	// 一个通用方法,用于通过执行人获取指定条件事务记录
	private List<Transaction> getSomeByAssigneeWithFlag(String assigneeName, boolean isFinishedForTask,
			boolean isFinishedForProcessInstance) {
		// 按照执行人查看所有已完成任务
		HistoricTaskInstanceQuery query = historyService.createHistoricTaskInstanceQuery();
		if (isFinishedForTask) {// 筛选 任务是否为结束状态
			query = query.finished();
		}
		List<HistoricTaskInstance> tasks = query.taskAssignee(assigneeName).list();
		// 查询任务所在流程实例id
		Set<String> piIds = new HashSet<String>();
		for (HistoricTaskInstance historicTaskInstance : tasks) {
			piIds.add(historicTaskInstance.getProcessInstanceId());
		}
		// 根据流程实例id获取所有流程实例
		List<HistoricProcessInstance> processInstances = historyService.createHistoricProcessInstanceQuery()
				.processInstanceIds(piIds).list();

		// 获取已完成事务流程[可以指定是否是已结束状态]对应事务key
		Set<String> tids = new HashSet<String>();
		for (HistoricProcessInstance historicProcessInstance : processInstances) {
			if (isFinishedForProcessInstance) {// 筛选 事务流程是否为结束状态
				if (historicProcessInstance.getEndTime() != null) {// 已结束
					tids.add(historicProcessInstance.getBusinessKey());
				}
			} else {
				if (historicProcessInstance.getEndTime() == null) {// 未结束
					tids.add(historicProcessInstance.getBusinessKey());
				}
			}
		}
		// 获取查询事务列表
		return this.findByTidSet(tids);
	}

	@Override
	public Transaction findById(Integer tid) {
		// TODO Auto-generated method stub
		if (tid != null) {
			return transactionMapper.selectByPrimaryKey(tid);
		} else {
			System.out.println("tid为空");
			return null;
		}
	}

	@Override
	public PageInfo<Transaction> findByQueryHandler(QueryHandler qh) {
		List<Transaction> list = qm.queryTransaction(qh);
		long rootSize = 0;
		int nowPage = 1;
		int pageSize = 5;
		if (qh == null || qh.getLimitSentence() == null) {// 没分页
			if (list != null) {
				rootSize = list.size();
				nowPage = qh.getPageNumber();
				pageSize = qh.getPageSize();
			}
		} else {
			rootSize = qm.findLastRows();
		}
		PageInfo<Transaction> pi = new PageInfo<Transaction>((int) rootSize, nowPage, pageSize);
		pi.setBasePageList(list);
		return pi;
	}

	// 获取tid关联流程实例
	private ProcessInstance getProcessInstanceByTid(Integer tid) {
		return runtimeService.createProcessInstanceQuery()
				.processInstanceBusinessKey(tid + "", BreInfo.PROCESS_DEFINITION_KEY).singleResult();
	}

	// 获取指定tid组的所有事务信息
	private List<Transaction> findByTidSet(Set<String> tids) {
		// 设定筛选条件
		QueryHandler qh = QueryHandler.creat().andColumnIn("tid", tids).set();
		// 执行查询,并返回
		return qm.queryTransaction(qh);
	}

	// 修改事务状态,以及超时时间
	private void editState(Integer tid, Integer stateCode, Date ttimeout) {
		Transaction one = new Transaction();
		one.setTid(tid);
		one.setTtimeout(ttimeout);
		one.setTstate(stateCode);
		if (transactionMapper.updateByPrimaryKeySelective(one) != 1) {
			throw new RuntimeException("事务状态/结束时间修改失败。。。");
		}
	}

	// 格式化输出指定用户组的用户
	private String formatUserInfoForGroup(String gid) {
		List<User> users = groupService.findUsersById(gid);
		if (users == null || users.size() < 1) {
			throw new RuntimeException(gid + ":组下没有用户,无法格式化输出用户...");
		}
		StringBuilder temp = new StringBuilder();
		int size = users.size();
		User one = null;
		for (int i = 0; i < size; i++) {
			one = users.get(i);
			temp.append(one.getFirstName());
			if (i != (size - 1)) {
				temp.append(",");
			}
		}
		return temp.toString();
	}

	// 验证指定任务是否存在指定流程实例中
	private boolean hasTaskInRunTimeById(String taskId) {
		List<Task> list = taskService.createTaskQuery().taskId(taskId).list();
		if (list == null || list.size() < 1) {
			return false;
		} else {
			return true;
		}
	}

	// 执行指定id任务,附加参数,并返回执行是否成功
	private boolean completeTask(String taskid, Map<String, Object> variables) {
		taskService.complete(taskid, variables);
		List<Task> list = taskService.createTaskQuery().taskId(taskid).list();
		return (list == null || list.size() < 1) ? true : false;
	}

	// 依据执行人/候选人名字以及事务tid,返回单一项任务[如果结果出现多个以上则选第一个找到的,没有,则抛异常]
	private Task getTaskByBusinessKeyAndAssignee(Integer tid, String assigneeName, boolean isChaim) {
		List<Task> list = null;
		if (isChaim) {// 查询以自己为候选人的任务
			list = taskService.createTaskQuery().processInstanceBusinessKey(tid + "").taskCandidateUser(assigneeName)
					.list();
		} else {// 查询以自己为执行人的任务
			list = taskService.createTaskQuery().processInstanceBusinessKey(tid + "").taskAssignee(assigneeName).list();
		}
		if (list == null || list.size() < 1) {
			throw new RuntimeException("没有查询到指定任务...");
		}
		return list.get(0);// 返回第一个任务
	}

	private cn.edu.nuc.bre.entity.Task getChildTaskByTidAndDeptName(Integer tid, String deptName) {
		QueryHandler qh = QueryHandler.creat().andColumnMark("tid", "=", tid + "").andColumnMark("dname", "=", deptName)
				.set();
		PageInfo<cn.edu.nuc.bre.entity.Task> pageInfo = childTaskService.findByQueryHandler(qh);
		// 验证是否正确获取
		if (pageInfo == null || pageInfo.getBasePageList() == null || pageInfo.getBasePageList().size() < 1) {
			throw new RuntimeException("子任务获取失败。。。");
		}
		return pageInfo.getBasePageList().get(0);
	}

}
